{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Time Series with BentoML and Prophet\n",
    "\n",
    "This notebook uses `BentoML` and `Kubeflow` to build, train and boot an api powered by a `Prophet` time series model. \n",
    "\n",
    "The below notebook focuses on building and serving a model using:\n",
    "- [BentoML](https://github.com/bentoml/BentoML)\n",
    "- Kubeflow [Fairing](https://www.kubeflow.org/docs/fairing/fairing-overview/) and [KFServing](https://github.com/kubeflow/kfserving)\n",
    "- [Prophet](https://facebook.github.io/prophet/)\n",
    "\n",
    "### Covid19 Data\n",
    "\n",
    "The notebook uses the [Covid19 Kaggle locality infection data](https://www.kaggle.com/sudalairajkumar/novel-corona-virus-2019-dataset#covid_19_data.csv) as our sample data. The notebook uses my home town `New York` as the locality."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "\n",
    "!pip install pandas sklearn auto-sklearn kubeflow-fairing grpcio kubeflow.metadata bentoml plotly fbprophet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import uuid\n",
    "from importlib import reload\n",
    "import grpc\n",
    "from kubeflow import fairing\n",
    "from kubeflow.fairing import constants\n",
    "import os\n",
    "import pandas as pd\n",
    "import logging\n",
    "\n",
    "logging.basicConfig(level=logging.WARN)\n",
    "logger = logging.getLogger(__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Config\n",
    "\n",
    "The values below will be used throughout this notebook, make sure to adjust these values to match your registry and namespace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The docker registry to store images in\n",
    "DOCKER_REGISTRY = \"iancoffey\"\n",
    "# The k8s namespace to run the experiment in\n",
    "k8s_namespace = \"default\"\n",
    "# Use local bentoml storage\n",
    "!bentoml config set yatai_service.url=\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Minio\n",
    "\n",
    "This notebook will use Minio as the development context storage for `Kubeflow Fairing`, but any of the supported blob storage (s3, gcp, etc) will work.\n",
    "\n",
    "To install Minio, apply the provided Minio manifest into the provided namespace.\n",
    "\n",
    "`kubectl apply -f ./manifests/minio -n $k8s_namespace`\n",
    "\n",
    "We will use the kubernetes sdk to determine the endpoints ip address and then build our `MinioContextSource`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from kubernetes import utils as k8s_utils\n",
    "from kubernetes import client as k8s_client\n",
    "from kubernetes import config as k8s_config\n",
    "from kubeflow.fairing.utils import is_running_in_k8s\n",
    "\n",
    "from kubeflow.fairing.cloud.k8s import MinioUploader\n",
    "from kubeflow.fairing.builders.cluster.minio_context import MinioContextSource\n",
    "\n",
    "if is_running_in_k8s():\n",
    "    k8s_config.load_incluster_config()\n",
    "else:\n",
    "    k8s_config.load_kube_config()\n",
    "\n",
    "api_client = k8s_client.CoreV1Api()\n",
    "minio_service_endpoint = api_client.read_namespaced_service(name='minio-service', namespace='default').spec.cluster_ip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'http://10.152.183.6:9000'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minio_endpoint = \"http://\"+minio_service_endpoint+\":9000\"\n",
    "minio_username = \"minio\"\n",
    "minio_key = \"minio123\"\n",
    "minio_region = \"us-east-1\"\n",
    "\n",
    "minio_uploader = MinioUploader(endpoint_url=minio_endpoint, minio_secret=minio_username, minio_secret_key=minio_key, region_name=minio_region)\n",
    "minio_context_source = MinioContextSource(endpoint_url=minio_endpoint, minio_secret=minio_username, minio_secret_key=minio_key, region_name=minio_region)\n",
    "minio_endpoint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Start: Preparing the Dataset\n",
    "\n",
    "\n",
    "To train our data, we need to split the data into train and test datasets as normal. We cant use the normal `train_test_split` function due to this being timeseries data, so we will have to define our own means of splitting the data by date."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fairing:include-cell\n",
    "data_path=\"covid_19_data.csv\"\n",
    "dframe = pd.read_csv(data_path, sep=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>y</th>\n",
       "      <th>ds</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4549</th>\n",
       "      <td>173.0</td>\n",
       "      <td>2020-03-10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4755</th>\n",
       "      <td>220.0</td>\n",
       "      <td>2020-03-11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4964</th>\n",
       "      <td>328.0</td>\n",
       "      <td>2020-03-12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5356</th>\n",
       "      <td>421.0</td>\n",
       "      <td>2020-03-13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5411</th>\n",
       "      <td>525.0</td>\n",
       "      <td>2020-03-14</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          y         ds\n",
       "4549  173.0 2020-03-10\n",
       "4755  220.0 2020-03-11\n",
       "4964  328.0 2020-03-12\n",
       "5356  421.0 2020-03-13\n",
       "5411  525.0 2020-03-14"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cols_of_interest = ['Confirmed', 'Province/State', 'ObservationDate']\n",
    "\n",
    "dframe['ObservationDate'] = pd.to_datetime(dframe['ObservationDate'])\n",
    "dframe.sort_index(inplace=True)\n",
    "\n",
    "trimmed_dframe=dframe[cols_of_interest]\n",
    "trimmed_dframe=trimmed_dframe.dropna()\n",
    "\n",
    "# Note the copy() here - else we would be working on a reference\n",
    "state_data = trimmed_dframe.loc[trimmed_dframe['Province/State'] == 'New York'].copy()\n",
    "state_data = state_data.drop('Province/State', axis=1).sort_index()\n",
    "\n",
    "state_data.rename(columns={'Confirmed': 'y', 'ObservationDate': 'ds'}, inplace=True)\n",
    "\n",
    "state_data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "color_pal = [\"#F8766D\", \"#D39200\", \"#93AA00\",\n",
    "             \"#00BA38\", \"#00C19F\", \"#00B9E3\",\n",
    "             \"#619CFF\", \"#DB72FB\"]\n",
    "\n",
    "\n",
    "_ = state_data.plot(x ='ds', y='y', kind='scatter', figsize=(15,5), title=\"Raw Covid19 Dataset\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "93"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "split_date = \"2020-05-15\"\n",
    "\n",
    "train_data = state_data[state_data['ds'] <= split_date].copy()\n",
    "test_data = state_data[state_data['ds'] >  split_date].copy()\n",
    "\n",
    "len(state_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Training\n",
    "\n",
    "Now that we have gathered and transformed our original covid19 timeseries data, we can create a new Prophet model and fit our training data.\n",
    "\n",
    "Then, we can use [make_future_dataframe](https://rdrr.io/cran/prophet/man/make_future_dataframe.html) to create a dataframe to contain our future timeseries and predictions. We pass `periods` as 10 to ensure we have 10 days predicted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[I 200626 12:49:35 utils:141] NumExpr defaulting to 2 threads.\n",
      "[I 200626 12:49:35 forecaster:919] Disabling yearly seasonality. Run prophet with yearly_seasonality=True to override this.\n",
      "[I 200626 12:49:35 forecaster:919] Disabling daily seasonality. Run prophet with daily_seasonality=True to override this.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ds</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>72</th>\n",
       "      <td>2020-05-21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>73</th>\n",
       "      <td>2020-05-22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>74</th>\n",
       "      <td>2020-05-23</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75</th>\n",
       "      <td>2020-05-24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>76</th>\n",
       "      <td>2020-05-25</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           ds\n",
       "72 2020-05-21\n",
       "73 2020-05-22\n",
       "74 2020-05-23\n",
       "75 2020-05-24\n",
       "76 2020-05-25"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Python\n",
    "import pandas as pd\n",
    "from fbprophet import Prophet\n",
    "\n",
    "m = Prophet()\n",
    "m.fit(train_data)\n",
    "future = m.make_future_dataframe(periods=10)\n",
    "future.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prediction\n",
    "\n",
    "We can use our new model to forcast our future timeseries and plot the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "72    362470.476200\n",
      "73    365496.015175\n",
      "74    369703.173415\n",
      "75    372333.226614\n",
      "76    374064.903150\n",
      "Name: yhat, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "forecast = m.predict(future)\n",
    "print(forecast['yhat'].tail())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig1 = m.plot(forecast, figsize = (15, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "additive_terms\n",
      "additive_terms_lower\n",
      "additive_terms_upper\n",
      "ds\n",
      "multiplicative_terms\n",
      "multiplicative_terms_lower\n",
      "multiplicative_terms_upper\n",
      "trend\n",
      "trend_lower\n",
      "trend_upper\n",
      "weekly\n",
      "weekly_lower\n",
      "weekly_upper\n",
      "yhat\n",
      "yhat_lower\n",
      "yhat_upper\n"
     ]
    }
   ],
   "source": [
    "for c in forecast.columns.sort_values():\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Projected vs Reality\n",
    "\n",
    "It is helpful to plot our predictions alongside our test data set, divided into two sections of time, defined by the boundary of the training and test datasets. We can see that the predictions were a bit too aggresive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set_style('darkgrid', {'axes.facecolor': '.9'})\n",
    "sns.set_palette(palette='deep')\n",
    "sns_c = sns.color_palette(palette='deep')\n",
    "\n",
    "threshold_date = pd.to_datetime(split_date)\n",
    "\n",
    "fig, ax = plt.subplots(figsize = (15, 10))\n",
    "sns.lineplot(x='ds', y='y', label='y_train', data=train_data, ax=ax)\n",
    "sns.lineplot(x='ds', y='y', label='y_test', data=test_data, ax=ax)\n",
    "sns.lineplot(x='ds', y='trend', data=forecast, ax=ax)\n",
    "ax.axvline(threshold_date, color=sns_c[3], linestyle='--', label='train test split')\n",
    "ax.legend(loc='upper left')\n",
    "ax.set(title='Confirmed Cases', ylabel='');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define BentoML Service\n",
    "\n",
    "We will now define the code we want to use to serve our model with BentoML.\n",
    "\n",
    "Our class and methods will be decorated to shows its artifact type and pip dependencies.\n",
    "\n",
    "Following that, lets reload the the new code and pack our BentoML service with the booster we have created!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting prophet_serve.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile prophet_serve.py\n",
    "\n",
    "import bentoml\n",
    "from bentoml.handlers import DataframeHandler\n",
    "from bentoml.artifact import PickleArtifact\n",
    "import fbprophet\n",
    "\n",
    "@bentoml.artifacts([PickleArtifact('model')])\n",
    "@bentoml.env(pip_dependencies=['fbprophet'])\n",
    "class ProphetServe(bentoml.BentoService):\n",
    "    @bentoml.api(DataframeHandler)\n",
    "    def predict(self, df):\n",
    "        return self.artifacts.model.predict(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[I 200626 12:49:42 __init__:116] Loading local BentoML config file: /home/jovyan/bentoml/bentoml.cfg\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2020-06-26 12:49:43,049] WARNING - bentoml.handlers.* will be deprecated after BentoML 1.0, use bentoml.adapters.* instead\n",
      "[2020-06-26 12:49:43,056] WARNING - DataframeHandler will be deprecated after BentoML 1.0, use DataframeInput instead\n",
      "[2020-06-26 12:49:43,108] WARNING - DataframeHandler will be deprecated after BentoML 1.0, use DataframeInput instead\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<module 'prophet_serve' from '/home/jovyan/prophet_serve.py'>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import prophet_serve\n",
    "import importlib\n",
    "importlib.reload(prophet_serve)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pack BentoML Service\n",
    "\n",
    "Lets pack the new service with our model, which would allow use to reference this iteration in the future and also build it into Docker images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[I 200626 12:49:46 migration:155] Context impl SQLiteImpl.\n",
      "[I 200626 12:49:46 migration:162] Will assume non-transactional DDL.\n",
      "[I 200626 12:49:46 migration:515] Running stamp_revision  -> a6b00ae45279\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2020-06-26 12:50:05,382] INFO - BentoService bundle 'ProphetServe:20200626124946_94E973' saved to: /home/jovyan/bentoml/repository/ProphetServe/20200626124946_94E973\n"
     ]
    }
   ],
   "source": [
    "from prophet_serve import ProphetServe\n",
    "\n",
    "bento_service = ProphetServe()\n",
    "bento_service.pack('model', m)\n",
    "saved_path = bento_service.save()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BentoML Service\n",
    "\n",
    "Now that we have a BentoML Service defined, lets checkout what that looks like via the cli:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[39mBENTO_SERVICE                       AGE                         APIS                                   ARTIFACTS\r\n",
      "ProphetServe:20200626124946_94E973  1 minute and 57.03 seconds  predict<DataframeInput:DefaultOutput>  model<PickleArtifact>\u001b[0m\r\n"
     ]
    }
   ],
   "source": [
    "!bentoml get ProphetServe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Explore the Bentoml service\n",
    "\n",
    "Lets pick a service to launch as a service. We will use the most recent one here, but you will need to edit the values below to match yours. This is purely for convience so that we can poke at the BentoML CLI quickly.\n",
    "\n",
    "We can see inside the autogenerated bento service directory that many files now exist, including a Dockerfile and requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[39m{\r\n",
      "  \"name\": \"ProphetServe\",\r\n",
      "  \"version\": \"20200626124946_94E973\",\r\n",
      "  \"uri\": {\r\n",
      "    \"type\": \"LOCAL\",\r\n",
      "    \"uri\": \"/home/jovyan/bentoml/repository/ProphetServe/20200626124946_94E973\"\r\n",
      "  },\r\n",
      "  \"bentoServiceMetadata\": {\r\n",
      "    \"name\": \"ProphetServe\",\r\n",
      "    \"version\": \"20200626124946_94E973\",\r\n",
      "    \"createdAt\": \"2020-06-26T12:50:05.310154Z\",\r\n",
      "    \"env\": {\r\n",
      "      \"condaEnv\": \"name: bentoml-ProphetServe\\nchannels:\\n- defaults\\ndependencies:\\n- python=3.7.6\\n- pip\\n\",\r\n",
      "      \"pipDependencies\": \"pandas\\nbentoml==0.8.1\\nfbprophet\",\r\n",
      "      \"pythonVersion\": \"3.7.6\",\r\n",
      "      \"dockerBaseImage\": \"bentoml/model-server:0.8.1\"\r\n",
      "    },\r\n",
      "    \"artifacts\": [\r\n",
      "      {\r\n",
      "        \"name\": \"model\",\r\n",
      "        \"artifactType\": \"PickleArtifact\"\r\n",
      "      }\r\n",
      "    ],\r\n",
      "    \"apis\": [\r\n",
      "      {\r\n",
      "        \"name\": \"predict\",\r\n",
      "        \"inputType\": \"DataframeInput\",\r\n",
      "        \"docs\": \"BentoService API\",\r\n",
      "        \"inputConfig\": {\r\n",
      "          \"orient\": \"records\",\r\n",
      "          \"typ\": \"frame\",\r\n",
      "          \"is_batch_input\": true,\r\n",
      "          \"input_dtypes\": null\r\n",
      "        },\r\n",
      "        \"outputConfig\": {\r\n",
      "          \"cors\": \"*\"\r\n",
      "        },\r\n",
      "        \"outputType\": \"DefaultOutput\"\r\n",
      "      }\r\n",
      "    ]\r\n",
      "  }\r\n",
      "}\u001b[0m\r\n"
     ]
    }
   ],
   "source": [
    "!bentoml get ProphetServe:20200626124946_94E973"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run Bento Service\n",
    "\n",
    "Now, using our BentoML service, we can make predictions like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2020-06-26 12:52:15,280] WARNING - bentoml.handlers.* will be deprecated after BentoML 1.0, use bentoml.adapters.* instead\n",
      "[2020-06-26 12:52:15,888] WARNING - DataframeHandler will be deprecated after BentoML 1.0, use DataframeInput instead\n",
      "INFO:numexpr.utils:NumExpr defaulting to 2 threads.\n",
      "          ds         trend  ...  multiplicative_terms_upper          yhat\n",
      "0 2021-07-14  1.471904e+06  ...                         0.0  1.471369e+06\n",
      "\n",
      "[1 rows x 16 columns]\n"
     ]
    }
   ],
   "source": [
    "!bentoml run ProphetServe:20200626124946_94E973 predict --input '{\"ds\":[\"2021-07-14\"]}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Explore BentoML Generated Artifacts\n",
    "\n",
    "BentoML generates a whole environment, including Dockerfile, for generating images based on these saved services.\n",
    "\n",
    "It is useful to `ls` this directory and see what it contains."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bentoml-init.sh       Dockerfile       ProphetServe\t setup.py\r\n",
      "bentoml.yml\t      environment.yml  README.md\r\n",
      "docker-entrypoint.sh  MANIFEST.in      requirements.txt\r\n"
     ]
    }
   ],
   "source": [
    "!ls /home/jovyan/bentoml/repository/ProphetServe/20200626124946_94E973"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stitching BentoML to Kubeflow Fairing\n",
    "\n",
    "We can build our models container with Kubeflow Fairing, a cool component which aims to improve data scientist life by streamlining the process of building, training, and deploying machine learning (ML) models.\n",
    "\n",
    "First we need to do some work to get the BentoML artifacts into our build context. We do this via the `preprocessing` work below. We are just taking the auto-generated `BentoML` Docker environment and stitching it together with `Kubeflow Fairing`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let build a docker image with builder using bentoml output\n",
    "from kubeflow.fairing.preprocessors.base import BasePreProcessor\n",
    "\n",
    "output_map =  {\n",
    "    \"/home/jovyan/bentoml/repository/ProphetServe/20200626124946_94E973/Dockerfile\": \"Dockerfile\",\n",
    "    \"/home/jovyan/bentoml/repository/ProphetServe/20200626124946_94E973/environment.yml\": \"environment.yml\",\n",
    "    \"/home/jovyan/bentoml/repository/ProphetServe/20200626124946_94E973/requirements.txt\": \"requirements.txt\",\n",
    "    \"/home/jovyan/bentoml/repository/ProphetServe/20200626124946_94E973/setup.py\": \"setup.py\",\n",
    "    \"/home/jovyan/bentoml/repository/ProphetServe/20200626124946_94E973/bentoml-init.sh\": \"bentoml-init.sh\",\n",
    "    \"/home/jovyan/bentoml/repository/ProphetServe/20200626124946_94E973/bentoml.yml\": \"bentoml.yml\",\n",
    "    \"/home/jovyan/bentoml/repository/ProphetServe/20200626124946_94E973/ProphetServe/\": \"ProphetServe/\",\n",
    "    \"/home/jovyan/bentoml/repository/ProphetServe/20200626124946_94E973/ProphetServe/prophet_serve.py\": \"ProphetServe/prophet_serve.py\",\n",
    "    \"/home/jovyan/bentoml/repository/ProphetServe/20200626124946_94E973/ProphetServe/artifacts/model.pkl\": \"ProphetServe/artifacts/model.pkl\",\n",
    "    \"/home/jovyan/bentoml/repository/ProphetServe/20200626124946_94E973/docker-entrypoint.sh\": \"docker-entrypoint.sh\",    \n",
    "}\n",
    "\n",
    "preprocessor = BasePreProcessor(output_map=output_map)\n",
    "\n",
    "preprocessor.preprocess()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cluster Building\n",
    "\n",
    "In this workflow, we want to develop our models locally, until we arrive at a model we want to deploy. From there we want to use cloud resources to build Docker images to deploy to our Kubernetes cluster.\n",
    "\n",
    "These Docker images will be built in our private cloud, perhaps using data and artifacts which are sensitive in nature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[I 200626 13:12:41 cluster:46] Building image using cluster builder.\n",
      "[W 200626 13:12:41 base:94] Dockerfile already exists in Fairing context, skipping...\n",
      "[I 200626 13:12:41 base:107] Creating docker context: /tmp/fairing_context_xiphsi3n\n",
      "[W 200626 13:12:41 base:94] Dockerfile already exists in Fairing context, skipping...\n",
      "[W 200626 13:12:57 manager:296] Waiting for fairing-builder-2v5vn-c74m6 to start...\n",
      "[W 200626 13:12:57 manager:296] Waiting for fairing-builder-2v5vn-c74m6 to start...\n",
      "[W 200626 13:12:58 manager:296] Waiting for fairing-builder-2v5vn-c74m6 to start...\n",
      "[I 200626 13:13:03 manager:302] Pod started running True\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[36mINFO\u001b[0m[0005] Retrieving image manifest bentoml/model-server:0.8.1\n",
      "\u001b[36mINFO\u001b[0m[0007] Retrieving image manifest bentoml/model-server:0.8.1\n",
      "\u001b[36mINFO\u001b[0m[0008] Built cross stage deps: map[]\n",
      "\u001b[36mINFO\u001b[0m[0008] Retrieving image manifest bentoml/model-server:0.8.1\n",
      "\u001b[36mINFO\u001b[0m[0009] Retrieving image manifest bentoml/model-server:0.8.1\n",
      "\u001b[36mINFO\u001b[0m[0010] Executing 0 build triggers\n",
      "\u001b[36mINFO\u001b[0m[0010] Unpacking rootfs as cmd COPY . /bento requires it.\n",
      "\u001b[36mINFO\u001b[0m[0109] COPY . /bento\n",
      "\u001b[36mINFO\u001b[0m[0109] Resolving 17 paths\n",
      "\u001b[36mINFO\u001b[0m[0109] Taking snapshot of files...\n",
      "\u001b[36mINFO\u001b[0m[0110] WORKDIR /bento\n",
      "\u001b[36mINFO\u001b[0m[0110] cmd: workdir\n",
      "\u001b[36mINFO\u001b[0m[0110] Changed working directory to /bento\n",
      "\u001b[36mINFO\u001b[0m[0110] ARG PIP_INDEX_URL=https://pypi.python.org/simple/\n",
      "\u001b[36mINFO\u001b[0m[0110] ARG PIP_TRUSTED_HOST=pypi.python.org\n",
      "\u001b[36mINFO\u001b[0m[0110] ENV PIP_INDEX_URL $PIP_INDEX_URL\n",
      "\u001b[36mINFO\u001b[0m[0110] ENV PIP_TRUSTED_HOST $PIP_TRUSTED_HOST\n",
      "\u001b[36mINFO\u001b[0m[0110] RUN if [ -f /bento/bentoml-init.sh ]; then bash -c /bento/bentoml-init.sh; fi\n",
      "\u001b[36mINFO\u001b[0m[0110] Taking snapshot of full filesystem...\n",
      "\u001b[36mINFO\u001b[0m[0111] Resolving 30305 paths\n",
      "\u001b[36mINFO\u001b[0m[0128] cmd: /bin/sh\n",
      "\u001b[36mINFO\u001b[0m[0128] args: [-c if [ -f /bento/bentoml-init.sh ]; then bash -c /bento/bentoml-init.sh; fi]\n",
      "\u001b[36mINFO\u001b[0m[0128] Running: [/bin/sh -c if [ -f /bento/bentoml-init.sh ]; then bash -c /bento/bentoml-init.sh; fi]\n",
      "+++ dirname /bento/bentoml-init.sh\n",
      "++ cd /bento\n",
      "++ pwd -P\n",
      "+ SAVED_BUNDLE_PATH=/bento\n",
      "+ cd /bento\n",
      "+ '[' -f ./setup.sh ']'\n",
      "+ command -v conda\n",
      "+ conda env update -n base -f ./environment.yml\n",
      "Collecting package metadata (repodata.json): ...working... done\n",
      "Solving environment: ...working... done\n",
      "\n",
      "Downloading and Extracting Packages\n",
      "pip-20.1.1           | 1.7 MB    | ########## | 100% \n",
      "certifi-2020.6.20    | 156 KB    | ########## | 100% \n",
      "openssl-1.1.1g       | 2.5 MB    | ########## | 100% \n",
      "Preparing transaction: ...working... done\n",
      "Verifying transaction: ...working... done\n",
      "Executing transaction: ...working... done\n",
      "\n",
      "\n",
      "==> WARNING: A newer version of conda exists. <==\n",
      "  current version: 4.8.2\n",
      "  latest version: 4.8.3\n",
      "\n",
      "Please update conda by running\n",
      "\n",
      "    $ conda update -n base -c defaults conda\n",
      "#\n",
      "# To activate this environment, use\n",
      "#\n",
      "#     $ conda activate base\n",
      "#\n",
      "# To deactivate an active environment, use\n",
      "#\n",
      "#     $ conda deactivate\n",
      "\n",
      "\n",
      "\n",
      "+ pip install -r ./requirements.txt\n",
      "Looking in indexes: https://pypi.python.org/simple/\n",
      "Collecting pandas\n",
      "  Downloading pandas-1.0.5-cp37-cp37m-manylinux1_x86_64.whl (10.1 MB)\n",
      "Requirement already satisfied: bentoml==0.8.1 in /opt/conda/lib/python3.7/site-packages (from -r ./requirements.txt (line 2)) (0.8.1)\n",
      "Collecting fbprophet\n",
      "  Downloading fbprophet-0.6.tar.gz (54 kB)\n",
      "Collecting pytz>=2017.2\n",
      "  Downloading pytz-2020.1-py2.py3-none-any.whl (510 kB)\n",
      "Requirement already satisfied: numpy>=1.13.3 in /opt/conda/lib/python3.7/site-packages (from pandas->-r ./requirements.txt (line 1)) (1.18.5)\n",
      "Requirement already satisfied: python-dateutil>=2.6.1 in /opt/conda/lib/python3.7/site-packages (from pandas->-r ./requirements.txt (line 1)) (2.8.0)\n",
      "Requirement already satisfied: grpcio<=1.27.2 in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.27.2)\n",
      "Requirement already satisfied: protobuf>=3.6.0 in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (3.12.2)\n",
      "Requirement already satisfied: py-zipkin in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (0.20.0)\n",
      "Requirement already satisfied: tabulate in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (0.8.7)\n",
      "Requirement already satisfied: cerberus in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.3.2)\n",
      "Requirement already satisfied: configparser in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (5.0.0)\n",
      "Requirement already satisfied: boto3 in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.14.3)\n",
      "Requirement already satisfied: psutil in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (5.7.0)\n",
      "Requirement already satisfied: sqlalchemy-utils in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (0.36.6)\n",
      "Requirement already satisfied: prometheus-client in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (0.8.0)\n",
      "Requirement already satisfied: certifi in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (2020.6.20)\n",
      "Requirement already satisfied: docker in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (4.2.1)\n",
      "Requirement already satisfied: requests in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (2.22.0)\n",
      "Requirement already satisfied: aiohttp in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (3.6.2)\n",
      "Requirement already satisfied: ruamel.yaml>=0.15.0 in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (0.16.10)\n",
      "Requirement already satisfied: flask in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.1.2)\n",
      "Requirement already satisfied: python-json-logger in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (0.1.11)\n",
      "Requirement already satisfied: packaging in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (20.4)\n",
      "Requirement already satisfied: alembic in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.4.2)\n",
      "Requirement already satisfied: sqlalchemy>=1.3.0 in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.3.17)\n",
      "Requirement already satisfied: humanfriendly in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (8.2)\n",
      "Requirement already satisfied: gunicorn in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (20.0.4)\n",
      "Requirement already satisfied: click>=7.0 in /opt/conda/lib/python3.7/site-packages (from bentoml==0.8.1->-r ./requirements.txt (line 2)) (7.1.2)\n",
      "Collecting Cython>=0.22\n",
      "  Downloading Cython-0.29.20-cp37-cp37m-manylinux1_x86_64.whl (2.0 MB)\n",
      "Collecting cmdstanpy==0.4\n",
      "  Downloading cmdstanpy-0.4.0-py3-none-any.whl (22 kB)\n",
      "Collecting pystan>=2.14\n",
      "  Downloading pystan-2.19.1.1-cp37-cp37m-manylinux1_x86_64.whl (67.3 MB)\n",
      "Collecting matplotlib>=2.0.0\n",
      "  Downloading matplotlib-3.2.2-cp37-cp37m-manylinux1_x86_64.whl (12.4 MB)\n",
      "Collecting LunarCalendar>=0.0.9\n",
      "  Downloading LunarCalendar-0.0.9-py2.py3-none-any.whl (18 kB)\n",
      "Collecting convertdate>=2.1.2\n",
      "  Downloading convertdate-2.2.1-py2.py3-none-any.whl (43 kB)\n",
      "Collecting holidays>=0.9.5\n",
      "  Downloading holidays-0.10.2.tar.gz (110 kB)\n",
      "Collecting setuptools-git>=1.2\n",
      "  Downloading setuptools_git-1.2-py2.py3-none-any.whl (10 kB)\n",
      "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.7/site-packages (from python-dateutil>=2.6.1->pandas->-r ./requirements.txt (line 1)) (1.14.0)\n",
      "Requirement already satisfied: setuptools in /opt/conda/lib/python3.7/site-packages (from protobuf>=3.6.0->bentoml==0.8.1->-r ./requirements.txt (line 2)) (45.2.0.post20200210)\n",
      "Requirement already satisfied: thriftpy2>=0.4.0 in /opt/conda/lib/python3.7/site-packages (from py-zipkin->bentoml==0.8.1->-r ./requirements.txt (line 2)) (0.4.11)\n",
      "Requirement already satisfied: botocore<1.18.0,>=1.17.3 in /opt/conda/lib/python3.7/site-packages (from boto3->bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.17.3)\n",
      "Requirement already satisfied: s3transfer<0.4.0,>=0.3.0 in /opt/conda/lib/python3.7/site-packages (from boto3->bentoml==0.8.1->-r ./requirements.txt (line 2)) (0.3.3)\n",
      "Requirement already satisfied: jmespath<1.0.0,>=0.7.1 in /opt/conda/lib/python3.7/site-packages (from boto3->bentoml==0.8.1->-r ./requirements.txt (line 2)) (0.10.0)\n",
      "Requirement already satisfied: websocket-client>=0.32.0 in /opt/conda/lib/python3.7/site-packages (from docker->bentoml==0.8.1->-r ./requirements.txt (line 2)) (0.57.0)\n",
      "Requirement already satisfied: chardet<3.1.0,>=3.0.2 in /opt/conda/lib/python3.7/site-packages (from requests->bentoml==0.8.1->-r ./requirements.txt (line 2)) (3.0.4)\n",
      "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /opt/conda/lib/python3.7/site-packages (from requests->bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.25.8)\n",
      "Requirement already satisfied: idna<2.9,>=2.5 in /opt/conda/lib/python3.7/site-packages (from requests->bentoml==0.8.1->-r ./requirements.txt (line 2)) (2.8)\n",
      "Requirement already satisfied: attrs>=17.3.0 in /opt/conda/lib/python3.7/site-packages (from aiohttp->bentoml==0.8.1->-r ./requirements.txt (line 2)) (19.3.0)\n",
      "Requirement already satisfied: multidict<5.0,>=4.5 in /opt/conda/lib/python3.7/site-packages (from aiohttp->bentoml==0.8.1->-r ./requirements.txt (line 2)) (4.7.6)\n",
      "Requirement already satisfied: yarl<2.0,>=1.0 in /opt/conda/lib/python3.7/site-packages (from aiohttp->bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.4.2)\n",
      "Requirement already satisfied: async-timeout<4.0,>=3.0 in /opt/conda/lib/python3.7/site-packages (from aiohttp->bentoml==0.8.1->-r ./requirements.txt (line 2)) (3.0.1)\n",
      "Requirement already satisfied: ruamel.yaml.clib>=0.1.2; platform_python_implementation == \"CPython\" and python_version < \"3.9\" in /opt/conda/lib/python3.7/site-packages (from ruamel.yaml>=0.15.0->bentoml==0.8.1->-r ./requirements.txt (line 2)) (0.2.0)\n",
      "Requirement already satisfied: Werkzeug>=0.15 in /opt/conda/lib/python3.7/site-packages (from flask->bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.0.1)\n",
      "Requirement already satisfied: Jinja2>=2.10.1 in /opt/conda/lib/python3.7/site-packages (from flask->bentoml==0.8.1->-r ./requirements.txt (line 2)) (2.11.2)\n",
      "Requirement already satisfied: itsdangerous>=0.24 in /opt/conda/lib/python3.7/site-packages (from flask->bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.1.0)\n",
      "Requirement already satisfied: pyparsing>=2.0.2 in /opt/conda/lib/python3.7/site-packages (from packaging->bentoml==0.8.1->-r ./requirements.txt (line 2)) (2.4.7)\n",
      "Requirement already satisfied: python-editor>=0.3 in /opt/conda/lib/python3.7/site-packages (from alembic->bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.0.4)\n",
      "Requirement already satisfied: Mako in /opt/conda/lib/python3.7/site-packages (from alembic->bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.1.3)\n",
      "Collecting kiwisolver>=1.0.1\n",
      "  Downloading kiwisolver-1.2.0-cp37-cp37m-manylinux1_x86_64.whl (88 kB)\n",
      "Collecting cycler>=0.10\n",
      "  Downloading cycler-0.10.0-py2.py3-none-any.whl (6.5 kB)\n",
      "Collecting ephem>=3.7.5.3\n",
      "  Downloading ephem-3.7.7.1-cp37-cp37m-manylinux2010_x86_64.whl (1.2 MB)\n",
      "Collecting pymeeus<=1,>=0.3.6\n",
      "  Downloading PyMeeus-0.3.7.tar.gz (732 kB)\n",
      "Collecting korean_lunar_calendar\n",
      "  Downloading korean_lunar_calendar-0.2.1-py3-none-any.whl (8.0 kB)\n",
      "Requirement already satisfied: ply<4.0,>=3.4 in /opt/conda/lib/python3.7/site-packages (from thriftpy2>=0.4.0->py-zipkin->bentoml==0.8.1->-r ./requirements.txt (line 2)) (3.11)\n",
      "Requirement already satisfied: docutils<0.16,>=0.10 in /opt/conda/lib/python3.7/site-packages (from botocore<1.18.0,>=1.17.3->boto3->bentoml==0.8.1->-r ./requirements.txt (line 2)) (0.15.2)\n",
      "Requirement already satisfied: MarkupSafe>=0.23 in /opt/conda/lib/python3.7/site-packages (from Jinja2>=2.10.1->flask->bentoml==0.8.1->-r ./requirements.txt (line 2)) (1.1.1)\n",
      "Building wheels for collected packages: fbprophet, holidays, pymeeus\n",
      "  Building wheel for fbprophet (setup.py): started\n",
      "  Building wheel for fbprophet (setup.py): finished with status 'error'\n",
      "  Running setup.py clean for fbprophet\n",
      "  ERROR: Command errored out with exit status 1:\n",
      "   command: /opt/conda/bin/python -u -c 'import sys, setuptools, tokenize; sys.argv[0] = '\"'\"'/tmp/pip-install-zh6gfvkx/fbprophet/setup.py'\"'\"'; __file__='\"'\"'/tmp/pip-install-zh6gfvkx/fbprophet/setup.py'\"'\"';f=getattr(tokenize, '\"'\"'open'\"'\"', open)(__file__);code=f.read().replace('\"'\"'\\r\\n'\"'\"', '\"'\"'\\n'\"'\"');f.close();exec(compile(code, __file__, '\"'\"'exec'\"'\"'))' bdist_wheel -d /tmp/pip-wheel-qwa0toa2\n",
      "       cwd: /tmp/pip-install-zh6gfvkx/fbprophet/\n",
      "  Complete output (40 lines):\n",
      "  running bdist_wheel\n",
      "  running build\n",
      "  running build_py\n",
      "  creating build\n",
      "  creating build/lib\n",
      "  creating build/lib/fbprophet\n",
      "  creating build/lib/fbprophet/stan_model\n",
      "  Traceback (most recent call last):\n",
      "    File \"<string>\", line 1, in <module>\n",
      "    File \"/tmp/pip-install-zh6gfvkx/fbprophet/setup.py\", line 148, in <module>\n",
      "      \"\"\"\n",
      "    File \"/opt/conda/lib/python3.7/site-packages/setuptools/__init__.py\", line 144, in setup\n",
      "      return distutils.core.setup(**attrs)\n",
      "    File \"/opt/conda/lib/python3.7/distutils/core.py\", line 148, in setup\n",
      "      dist.run_commands()\n",
      "    File \"/opt/conda/lib/python3.7/distutils/dist.py\", line 966, in run_commands\n",
      "      self.run_command(cmd)\n",
      "    File \"/opt/conda/lib/python3.7/distutils/dist.py\", line 985, in run_command\n",
      "      cmd_obj.run()\n",
      "    File \"/opt/conda/lib/python3.7/site-packages/wheel/bdist_wheel.py\", line 223, in run\n",
      "      self.run_command('build')\n",
      "    File \"/opt/conda/lib/python3.7/distutils/cmd.py\", line 313, in run_command\n",
      "      self.distribution.run_command(command)\n",
      "    File \"/opt/conda/lib/python3.7/distutils/dist.py\", line 985, in run_command\n",
      "      cmd_obj.run()\n",
      "    File \"/opt/conda/lib/python3.7/distutils/command/build.py\", line 135, in run\n",
      "      self.run_command(cmd_name)\n",
      "    File \"/opt/conda/lib/python3.7/distutils/cmd.py\", line 313, in run_command\n",
      "      self.distribution.run_command(command)\n",
      "    File \"/opt/conda/lib/python3.7/distutils/dist.py\", line 985, in run_command\n",
      "      cmd_obj.run()\n",
      "    File \"/tmp/pip-install-zh6gfvkx/fbprophet/setup.py\", line 48, in run\n",
      "      build_models(target_dir)\n",
      "    File \"/tmp/pip-install-zh6gfvkx/fbprophet/setup.py\", line 36, in build_models\n",
      "      from fbprophet.models import StanBackendEnum\n",
      "    File \"/tmp/pip-install-zh6gfvkx/fbprophet/fbprophet/__init__.py\", line 8, in <module>\n",
      "      from fbprophet.forecaster import Prophet\n",
      "    File \"/tmp/pip-install-zh6gfvkx/fbprophet/fbprophet/forecaster.py\", line 15, in <module>\n",
      "      import pandas as pd\n",
      "  ModuleNotFoundError: No module named 'pandas'\n",
      "  ----------------------------------------\n",
      "  ERROR: Failed building wheel for fbprophet\n",
      "  Building wheel for holidays (setup.py): started\n",
      "  Building wheel for holidays (setup.py): finished with status 'done'\n",
      "  Created wheel for holidays: filename=holidays-0.10.2-py3-none-any.whl size=111560 sha256=e42528ffa1b9947182d30cec4b982d0e0572c753b64acb0c200b1855399f89fd\n",
      "  Stored in directory: /root/.cache/pip/wheels/90/4e/82/f4130a57eb035c4344489ca14caff692590719b5f375540f53\n",
      "  Building wheel for pymeeus (setup.py): started\n",
      "  Building wheel for pymeeus (setup.py): finished with status 'done'\n",
      "  Created wheel for pymeeus: filename=PyMeeus-0.3.7-py3-none-any.whl size=702876 sha256=441c449f932be4813828e725a7a9db2d211bc003bf0634cc25d516f9a715c30a\n",
      "  Stored in directory: /root/.cache/pip/wheels/80/32/5f/2a67880d4ce584b9cf99146f9945e46942dfb010a9382c6ff5\n",
      "Successfully built holidays pymeeus\n",
      "Failed to build fbprophet\n",
      "Installing collected packages: pytz, pandas, Cython, cmdstanpy, pystan, kiwisolver, cycler, matplotlib, ephem, LunarCalendar, pymeeus, convertdate, korean-lunar-calendar, holidays, setuptools-git, fbprophet\n",
      "    Running setup.py install for fbprophet: started\n",
      "    Running setup.py install for fbprophet: still running...\n",
      "    Running setup.py install for fbprophet: finished with status 'done'\n",
      "Successfully installed Cython-0.29.20 LunarCalendar-0.0.9 cmdstanpy-0.4.0 convertdate-2.2.1 cycler-0.10.0 ephem-3.7.7.1 fbprophet-0.6 holidays-0.10.2 kiwisolver-1.2.0 korean-lunar-calendar-0.2.1 matplotlib-3.2.2 pandas-1.0.5 pymeeus-0.3.7 pystan-2.19.1.1 pytz-2020.1 setuptools-git-1.2\n",
      "+ for filename in ./bundled_pip_dependencies/*.tar.gz\n",
      "+ '[' -e './bundled_pip_dependencies/*.tar.gz' ']'\n",
      "+ continue\n",
      "\u001b[36mINFO\u001b[0m[0421] Taking snapshot of full filesystem...\n",
      "\u001b[36mINFO\u001b[0m[0422] Resolving 57440 paths\n",
      "\u001b[36mINFO\u001b[0m[0521] ENV PORT 5000\n",
      "\u001b[36mINFO\u001b[0m[0521] EXPOSE $PORT\n",
      "\u001b[36mINFO\u001b[0m[0521] cmd: EXPOSE\n",
      "\u001b[36mINFO\u001b[0m[0521] Adding exposed port: 5000/tcp\n",
      "\u001b[36mINFO\u001b[0m[0521] COPY docker-entrypoint.sh /usr/local/bin/\n",
      "\u001b[36mINFO\u001b[0m[0521] Resolving 1 paths\n",
      "\u001b[36mINFO\u001b[0m[0521] Taking snapshot of files...\n",
      "\u001b[36mINFO\u001b[0m[0521] ENTRYPOINT [ \"docker-entrypoint.sh\" ]\n",
      "\u001b[36mINFO\u001b[0m[0521] CMD [\"bentoml\", \"serve-gunicorn\", \"/bento\"]\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "from kubeflow.fairing.builders import cluster\n",
    "from kubeflow.fairing import constants\n",
    "\n",
    "constants.constants.KANIKO_IMAGE = \"gcr.io/kaniko-project/executor:v0.22.0\"\n",
    "\n",
    "cluster_builder = cluster.cluster.ClusterBuilder(registry=DOCKER_REGISTRY,\n",
    "                                                 preprocessor=preprocessor,\n",
    "                                                 dockerfile_path=\"Dockerfile\",\n",
    "                                                 context_source=minio_context_source)\n",
    "\n",
    "print(cluster_builder.build())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deploy the Service\n",
    "\n",
    "There are several good ways we can deploy the model we have fit, trained and crafted into an image. For this example, we will deploy the model service with KFServing by creating an `InferenceService`. This project uses Knative Serving to deploy the service and setup its routes. Under the covers Istio is at work routing our traffic to this new service.\n",
    "\n",
    "For local development, set the cluster local tags and set the domain to reflect `svc.cluster.local` as described in [these docs](https://knative.dev/docs/serving/cluster-local-route/).\n",
    "\n",
    "Lets use the Custom Object K8S API to deploy the pickled Prophet model we have defined with BentoML and built with Fairing.\n",
    "\n",
    "## KFServing `InferenceService`\n",
    "\n",
    "Below, [we define and launch an inferenceservice](https://docs.bentoml.org/en/latest/deployment/kfserving.html#deploy-bentoservice-to-kfserving), which in turn reconciles into a Knative service."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'apiVersion': 'serving.kubeflow.org/v1alpha2',\n",
       " 'kind': 'InferenceService',\n",
       " 'metadata': {'creationTimestamp': '2020-06-26T14:08:34Z',\n",
       "  'generation': 1,\n",
       "  'name': 'prophet-model-api',\n",
       "  'namespace': 'default',\n",
       "  'resourceVersion': '2962980',\n",
       "  'selfLink': '/apis/serving.kubeflow.org/v1alpha2/namespaces/default/inferenceservices/prophet-model-api',\n",
       "  'uid': '58f289ac-a802-44d1-ab0f-928dcc283ad5'},\n",
       " 'spec': {'default': {'predictor': {'custom': {'container': {'image': 'iancoffey/fairing-job:485938BA',\n",
       "      'name': 'prophet-model-api-container',\n",
       "      'ports': [{'containerPort': 5000}],\n",
       "      'resources': {'limits': {'cpu': '1', 'memory': '2Gi'},\n",
       "       'requests': {'cpu': '1', 'memory': '2Gi'}}}}}}},\n",
       " 'status': {}}"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from kfserving import V1alpha2EndpointSpec,V1alpha2InferenceServiceSpec, V1alpha2InferenceService, V1alpha2CustomSpec\n",
    "from kfserving import KFServingClient\n",
    "from kfserving import constants\n",
    "\n",
    "containerSpec = k8s_client.V1Container(\n",
    "    name=\"prophet-model-api-container\",\n",
    "    image=cluster_builder.image_tag,\n",
    "    ports=[k8s_client.V1ContainerPort(container_port=5000)])\n",
    "\n",
    "default_custom_model_spec = V1alpha2EndpointSpec(predictor=V1alpha2PredictorSpec(custom=V1alpha2CustomSpec(container=containerSpec)))\n",
    "\n",
    "metadata = k8s_client.V1ObjectMeta(\n",
    "    name=\"prophet-model-api\", namespace=\"default\",\n",
    ")\n",
    "\n",
    "isvc = V1alpha2InferenceService(api_version=constants.KFSERVING_GROUP + '/' + constants.KFSERVING_VERSION,\n",
    "                          kind=constants.KFSERVING_KIND,\n",
    "                          metadata=metadata,\n",
    "                          spec=V1alpha2InferenceServiceSpec(default=default_custom_model_spec))\n",
    "\n",
    "KFServing = KFServingClient()\n",
    "KFServing.create(isvc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Querying the Inference Server\n",
    "\n",
    "Now we are ready to use our endpoint. Lets post a test date with curl and see our shiny brand new API endpoint perform."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r\n",
      "\r\n",
      "\r\n",
      "\r\n",
      "\r\n",
      "\r\n",
      "\r\n",
      "\r\n",
      "\r\n",
      "[{\"ds\":1594684800000,\"trend\":506162.6572053498,\"yhat_lower\":301556.5952542502,\"yhat_upper\":688911.3268348163,\"trend_lower\":301342.1933916567,\"trend_upper\":691285.190480784,\"additive_terms\":-645.3873742295,\"additive_terms_lower\":-645.3873742295,\"additive_terms_upper\":-645.3873742295,\"weekly\":-645.3873742295,\"weekly_lower\":-645.3873742295,\"weekly_upper\":-645.3873742295,\"multiplicative_terms\":0.0,\"multiplicative_terms_lower\":0.0,\"multiplicative_terms_upper\":0.0,\"yhat\":505517.2698311203}]"
     ]
    }
   ],
   "source": [
    "!curl -i --header \"Content-Type: application/json\" -X POST http://prophet-model-api-predictor-default-7z66r-private.default.svc.cluster.local/predict --data '{\"ds\":[\"2020-07-14\"]}' "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Deployed\n",
    "\n",
    "Now we have a fitted and trained a model, defined a Service with BentoML, built an image for it using Kubeflow Fairing and deployed it to our Kubernetes dev cluster with KFServing. Party!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
